/**
 *  test7.c - Test semInit(), semGain() and semPost()
 *            It runs on ARMulator or ARM7TDMI CPU.
 *
 *  Copyright (C) 2008-2009  ZhangHu
 *  All rights reserved.
 *  E-MAIL: anmnmnly@gmail.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#include "include/core.h"
#include "include/sem.h"

#define STACK_SIZE 1024

sem_t *test_sem0  = NULL; /* task0   - task9  */
sem_t *test_sem1  = NULL; /* task10  - task19  */
sem_t *test_sem2  = NULL; /* task20  - task29  */
sem_t *test_sem3  = NULL; /* task30  - task39  */
sem_t *test_sem4  = NULL; /* task40  - task49  */
sem_t *test_sem5  = NULL; /* task50  - task59  */
sem_t *test_sem6  = NULL; /* task60  - task69  */
sem_t *test_sem7  = NULL; /* task70  - task79  */
sem_t *test_sem8  = NULL; /* task80  - task89  */
sem_t *test_sem9  = NULL; /* task90  - task99  */

#define TEST_SEM_ID0 100
#define TEST_SEM_ID1 101
#define TEST_SEM_ID2 102
#define TEST_SEM_ID3 103
#define TEST_SEM_ID4 104
#define TEST_SEM_ID5 105
#define TEST_SEM_ID6 106
#define TEST_SEM_ID7 107
#define TEST_SEM_ID8 108
#define TEST_SEM_ID9 109


static int group0_count = 0;
static int group1_count = 0;
static int group2_count = 0;
static int group3_count = 0;
static int group4_count = 0;
static int group5_count = 0;
static int group6_count = 0;
static int group7_count = 0;
static int group8_count = 0;
static int group9_count = 0;



static void Task0(void) {
    while(1) {
        semGain(TEST_SEM_ID0, NULL);
        group0_count++;
        osWait(65);
        semPost(TEST_SEM_ID0, test_sem0);
    }
}



static void Task1(void) {
    while(1) {
        semGain(TEST_SEM_ID0, NULL);
        group0_count++;
        osWait(65);
        semPost(TEST_SEM_ID0, test_sem0);
    }
}



static void Task2(void) {
    while(1) {
        semGain(TEST_SEM_ID0, NULL);
        group0_count++;
        osWait(68);
        semPost(TEST_SEM_ID0, test_sem0);
    }
}



static void Task3(void) {
    while(1) {
        semGain(TEST_SEM_ID0, NULL);
        group0_count++;
        osWait(68);
        semPost(TEST_SEM_ID0, test_sem0);
    }
}



static void Task4(void) {
    while(1) {
        semGain(TEST_SEM_ID0, NULL);
        group0_count++;
        osWait(65);
        semPost(TEST_SEM_ID0, test_sem0);
    }
}



static void Task5(void) {
    while(1) {
        semGain(TEST_SEM_ID0, test_sem0);
        group0_count--;
        osWait(65);
        semPost(TEST_SEM_ID0, NULL);
    }
}



static void Task6(void) {
    while(1) {
        semGain(TEST_SEM_ID0, test_sem0);
        group0_count--;
        osWait(45);
        semPost(TEST_SEM_ID0, NULL);
    }
}



static void Task7(void) {
    while(1) {
        semGain(TEST_SEM_ID0, test_sem0);
        group0_count--;
        osWait(68);
        semPost(TEST_SEM_ID0, NULL);
    }
}



static void Task8(void) {
    while(1) {
        semGain(TEST_SEM_ID0, test_sem0);
        group0_count--;
        osWait(68);
        semPost(TEST_SEM_ID0, NULL);
    }
}



static void Task9(void) {
    while(1) {
        semGain(TEST_SEM_ID0, test_sem0);
        group0_count--;
        osWait(568);
        semPost(TEST_SEM_ID0, NULL);
    }
}



static void Task10(void) {
    while(1) {
        semGain(TEST_SEM_ID1, test_sem1);
        group1_count++;
        osWait(68);
        semPost(TEST_SEM_ID1, NULL);
    }
}



static void Task11(void) {
    while(1) {
        semGain(TEST_SEM_ID1, test_sem1);
        group1_count++;
        osWait(458);
        semPost(TEST_SEM_ID1, NULL);
    }
}



static void Task12(void) {
    while(1) {
        semGain(TEST_SEM_ID1, test_sem1);
        group1_count++;
        osWait(35);
        semPost(TEST_SEM_ID1, NULL);
    }
}



static void Task13(void) {
    while(1) {
        semGain(TEST_SEM_ID1, test_sem1);
        group1_count++;
        osWait(45);
        semPost(TEST_SEM_ID1, NULL);
    }
}



static void Task14(void) {
    while(1) {
        semGain(TEST_SEM_ID1, test_sem1);
        group1_count++;
        osWait(23);
        semPost(TEST_SEM_ID1, NULL);
    }
}



static void Task15(void) {
    while(1) {
        semGain(TEST_SEM_ID1, NULL);
        group1_count--;
        osWait(35);
        semPost(TEST_SEM_ID1, test_sem1);
    }
}



static void Task16(void) {
    while(1) {
        semGain(TEST_SEM_ID1, NULL);
        group1_count--;
        osWait(23);
        semPost(TEST_SEM_ID1, test_sem1);
    }
}



static void Task17(void) {
    while(1) {
        semGain(TEST_SEM_ID1, NULL);
        group1_count--;
        osWait(35);
        semPost(TEST_SEM_ID1, test_sem1);
    }
}



static void Task18(void) {
    while(1) {
        semGain(TEST_SEM_ID1, NULL);
        group1_count--;
        osWait(24);
        semPost(TEST_SEM_ID1, test_sem1);
    }
}



static void Task19(void) {
    while(1) {
        semGain(TEST_SEM_ID1, NULL);
        group1_count--;
        osWait(23);
        semPost(TEST_SEM_ID1, test_sem1);
    }
}



static void Task20(void) {
    while(1) {
        semGain(TEST_SEM_ID2, NULL);
        group2_count++;
        osWait(24);
        semPost(TEST_SEM_ID2, test_sem2);
    }
}



static void Task21(void) {
    while(1) {
        semGain(TEST_SEM_ID2, NULL);
        group2_count++;
        osWait(23);
        semPost(TEST_SEM_ID2, test_sem2);
    }
}



static void Task22(void) {
    while(1) {
        semGain(TEST_SEM_ID2, NULL);
        group2_count++;
        osWait(35);
        semPost(TEST_SEM_ID2, test_sem2);
    }
}



static void Task23(void) {
    while(1) {
        semGain(TEST_SEM_ID2, NULL);
        group2_count++;
        osWait(123);
        semPost(TEST_SEM_ID2, test_sem2);
    }
}



static void Task24(void) {
    while(1) {
        semGain(TEST_SEM_ID2, NULL);
        group2_count++;
        osWait(100);
        semPost(TEST_SEM_ID2, test_sem2);
    }
}



static void Task25(void) {
    while(1) {
        semGain(TEST_SEM_ID2, test_sem2);
        group2_count--;
        osWait(56);
        semPost(TEST_SEM_ID2, NULL);
    }
}



static void Task26(void) {
    while(1) {
        semGain(TEST_SEM_ID2, test_sem2);
        group2_count--;
        osWait(58);
        semPost(TEST_SEM_ID2, NULL);
    }
}



static void Task27(void) {
    while(1) {
        semGain(TEST_SEM_ID2, test_sem2);
        group2_count--;
        osWait(56);
        semPost(TEST_SEM_ID2, NULL);
    }
}



static void Task28(void) {
    while(1) {
        semGain(TEST_SEM_ID2, test_sem2);
        group2_count--;
        osWait(45);
        semPost(TEST_SEM_ID2, NULL);
    }
}



static void Task29(void) {
    while(1) {
        semGain(TEST_SEM_ID2, test_sem2);
        group2_count--;
        osWait(156);
        semPost(TEST_SEM_ID2, NULL);
    }
}



static void Task30(void) {
    while(1) {
        semGain(TEST_SEM_ID3, test_sem3);
        group3_count--;
        osWait(125);
        semPost(TEST_SEM_ID3, NULL);
    }
}



static void Task31(void) {
    while(1) {
        semGain(TEST_SEM_ID3, test_sem3);
        group3_count--;
        osWait(354);
        semPost(TEST_SEM_ID3, NULL);
    }
}



static void Task32(void) {
    while(1) {
        semGain(TEST_SEM_ID3, test_sem3);
        group3_count--;
        osWait(125);
        semPost(TEST_SEM_ID3, NULL);
    }
}



static void Task33(void) {
    while(1) {
        semGain(TEST_SEM_ID3, test_sem3);
        group3_count--;
        osWait(12);
        semPost(TEST_SEM_ID3, NULL);
    }
}



static void Task34(void) {
    while(1) {
        semGain(TEST_SEM_ID3, test_sem3);
        group3_count--;
        osWait(568);
        semPost(TEST_SEM_ID3, NULL);
    }
}



static void Task35(void) {
    while(1) {
        semGain(TEST_SEM_ID3, NULL);
        group3_count++;
        osWait(456);
        semPost(TEST_SEM_ID3, test_sem3);
    }
}



static void Task36(void) {
    while(1) {
        semGain(TEST_SEM_ID3, NULL);
        group3_count++;
        osWait(125);
        semPost(TEST_SEM_ID3, test_sem3);
    }
}



static void Task37(void) {
    while(1) {
        semGain(TEST_SEM_ID3, NULL);
        group3_count++;
        osWait(111);
        semPost(TEST_SEM_ID3, test_sem3);
    }
}



static void Task38(void) {
    while(1) {
        semGain(TEST_SEM_ID3, NULL);
        group3_count++;
        osWait(12);
        semPost(TEST_SEM_ID3, test_sem3);
    }
}



static void Task39(void) {
    while(1) {
        semGain(TEST_SEM_ID3, NULL);
        group3_count++;
        osWait(12);
        semPost(TEST_SEM_ID3, test_sem3);
    }
}



static void Task40(void) {
    while(1) {
        semGain(TEST_SEM_ID4, NULL);
        group4_count--;
        osWait(2);
        semPost(TEST_SEM_ID4, test_sem4);
    }
}



static void Task41(void) {
    while(1) {
        semGain(TEST_SEM_ID4, NULL);
        group4_count--;
        osWait(32);
        semPost(TEST_SEM_ID4, test_sem4);
    }
}



static void Task42(void) {
    while(1) {
        semGain(TEST_SEM_ID4, NULL);
        group4_count--;
        osWait(44);
        semPost(TEST_SEM_ID4, test_sem4);
    }
}



static void Task43(void) {
    while(1) {
        semGain(TEST_SEM_ID4, NULL);
        group4_count--;
        osWait(45);
        semPost(TEST_SEM_ID4, test_sem4);
    }
}



static void Task44(void) {
    while(1) {
        semGain(TEST_SEM_ID4, NULL);
        group4_count--;
        osWait(25);
        semPost(TEST_SEM_ID4, test_sem4);
    }
}



static void Task45(void) {
    while(1) {
        semGain(TEST_SEM_ID4, test_sem4);
        group4_count++;
        osWait(32);
        semPost(TEST_SEM_ID4, NULL);
    }
}



static void Task46(void) {
    while(1) {
        semGain(TEST_SEM_ID4, test_sem4);
        group4_count++;
        osWait(56);
        semPost(TEST_SEM_ID4, NULL);
    }
}



static void Task47(void) {
    while(1) {
        semGain(TEST_SEM_ID4, test_sem4);
        group4_count++;
        osWait(45);
        semPost(TEST_SEM_ID4, NULL);
    }
}



static void Task48(void) {
    while(1) {
        semGain(TEST_SEM_ID4, test_sem4);
        group4_count++;
        osWait(4);
        semPost(TEST_SEM_ID4, NULL);
    }
}



static void Task49(void) {
    while(1) {
        semGain(TEST_SEM_ID4, test_sem4);
        group4_count++;
        osWait(10);
        semPost(TEST_SEM_ID4, NULL);
    }
}



static void Task50(void) {
    while(1) {
        semGain(TEST_SEM_ID5, test_sem5);
        group5_count--;
        osWait(86);
        semPost(TEST_SEM_ID5, NULL);
    }
}



static void Task51(void) {
    while(1) {
        semGain(TEST_SEM_ID5, test_sem5);
        group5_count--;
        osWait(100);
        semPost(TEST_SEM_ID5, NULL);
    }
}



static void Task52(void) {
    while(1) {
        semGain(TEST_SEM_ID5, test_sem5);
        group5_count--;
        osWait(35);
        semPost(TEST_SEM_ID5, NULL);
    }
}



static void Task53(void) {
    while(1) {
        semGain(TEST_SEM_ID5, test_sem5);
        group5_count--;
        osWait(96);
        semPost(TEST_SEM_ID5, NULL);
    }
}



static void Task54(void) {
    while(1) {
        semGain(TEST_SEM_ID5, test_sem5);
        group5_count--;
        osWait(78);
        semPost(TEST_SEM_ID5, NULL);
    }
}



static void Task55(void) {
    while(1) {
        semGain(TEST_SEM_ID5, NULL);
        group5_count++;
        osWait(36);
        semPost(TEST_SEM_ID5, test_sem5);
    }
}



static void Task56(void) {
    while(1) {
        semGain(TEST_SEM_ID5, NULL);
        group5_count++;
        osWait(35);
        semPost(TEST_SEM_ID5, test_sem5);
    }
}



static void Task57(void) {
    while(1) {
        semGain(TEST_SEM_ID5, NULL);
        group5_count++;
        osWait(25);
        semPost(TEST_SEM_ID5, test_sem5);
    }
}



static void Task58(void) {
    while(1) {
        semGain(TEST_SEM_ID5, NULL);
        group5_count++;
        osWait(100);
        semPost(TEST_SEM_ID5, test_sem5);
    }
}



static void Task59(void) {
    while(1) {
        semGain(TEST_SEM_ID5, NULL);
        group5_count++;
        osWait(16);
        semPost(TEST_SEM_ID5, test_sem5);
    }
}



static void Task60(void) {
    while(1) {
        semGain(TEST_SEM_ID6, NULL);
        group6_count++;
        osWait(100);
        semPost(TEST_SEM_ID6, test_sem6);
    }
}



static void Task61(void) {
    while(1) {
        semGain(TEST_SEM_ID6, NULL);
        group6_count++;
        osWait(200);
        semPost(TEST_SEM_ID6, test_sem6);
    }
}



static void Task62(void) {
    while(1) {
        semGain(TEST_SEM_ID6, NULL);
        group6_count++;
        osWait(100);
        semPost(TEST_SEM_ID6, test_sem6);
    }
}



static void Task63(void) {
    while(1) {
        semGain(TEST_SEM_ID6, NULL);
        group6_count++;
        osWait(100);
        semPost(TEST_SEM_ID6, test_sem6);
    }
}



static void Task64(void) {
    while(1) {
        semGain(TEST_SEM_ID6, NULL);
        group6_count++;
        osWait(50);
        semPost(TEST_SEM_ID6, test_sem6);
    }
}



static void Task65(void) {
    while(1) {
        semGain(TEST_SEM_ID6, test_sem6);
        group6_count--;
        osWait(100);
        semPost(TEST_SEM_ID6, NULL);
    }
}



static void Task66(void) {
    while(1) {
        semGain(TEST_SEM_ID6, test_sem6);
        group6_count--;
        osWait(20);
        semPost(TEST_SEM_ID6, NULL);
    }
}



static void Task67(void) {
    while(1) {
        semGain(TEST_SEM_ID6, test_sem6);
        group6_count--;
        osWait(100);
        semPost(TEST_SEM_ID6, NULL);
    }
}



static void Task68(void) {
    while(1) {
        semGain(TEST_SEM_ID6, test_sem6);
        group6_count--;
        osWait(10);
        semPost(TEST_SEM_ID6, NULL);
    }
}



static void Task69(void) {
    while(1) {
        semGain(TEST_SEM_ID6, test_sem6);
        group6_count--;
        osWait(100);
        semPost(TEST_SEM_ID6, NULL);
    }
}



static void Task70(void) {
    while(1) {
        semGain(TEST_SEM_ID7, test_sem7);
        group7_count--;
        osWait(15);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task71(void) {
    while(1) {
        semGain(TEST_SEM_ID7, test_sem7);
        group7_count--;
        osWait(12);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task72(void) {
    while(1) {
        semGain(TEST_SEM_ID7, test_sem7);
        group7_count--;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task73(void) {
    while(1) {
        semGain(TEST_SEM_ID7, test_sem7);
        group7_count--;
        osWait(11);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task74(void) {
    while(1) {
        semGain(TEST_SEM_ID7, test_sem7);
        group7_count--;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task75(void) {
    while(1) {
        semGain(TEST_SEM_ID7, NULL);
        group7_count++;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task76(void) {
    while(1) {
        semGain(TEST_SEM_ID7, NULL);
        group7_count++;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task77(void) {
    while(1) {
        semGain(TEST_SEM_ID7, NULL);
        group7_count++;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task78(void) {
    while(1) {
        semGain(TEST_SEM_ID7, NULL);
        group7_count++;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task79(void) {
    while(1) {
        semGain(TEST_SEM_ID7, NULL);
        group7_count++;
        osWait(100);
        semPost(TEST_SEM_ID7, test_sem7);
    }
}



static void Task80(void) {
    while(1) {
        semGain(TEST_SEM_ID8, NULL);
        group8_count++;
        osWait(100);
        semPost(TEST_SEM_ID8, test_sem8);
    }
}



static void Task81(void) {
    while(1) {
        semGain(TEST_SEM_ID8, NULL);
        group8_count++;
        osWait(100);
        semPost(TEST_SEM_ID8, test_sem8);
    }
}



static void Task82(void) {
    while(1) {
        semGain(TEST_SEM_ID8, NULL);
        group8_count++;
        osWait(100);
        semPost(TEST_SEM_ID8, test_sem8);
    }
}



static void Task83(void) {
    while(1) {
        semGain(TEST_SEM_ID8, NULL);
        group8_count++;
        osWait(100);
        semPost(TEST_SEM_ID8, test_sem8);
    }
}



static void Task84(void) {
    while(1) {
        semGain(TEST_SEM_ID8, NULL);
        group8_count++;
        osWait(100);
        semPost(TEST_SEM_ID8, test_sem8);
    }
}



static void Task85(void) {
    while(1) {
        semGain(TEST_SEM_ID8, test_sem8);
        group8_count--;
        osWait(100);
        semPost(TEST_SEM_ID8, NULL);
    }
}



static void Task86(void) {
    while(1) {
        semGain(TEST_SEM_ID8, test_sem8);
        group8_count--;
        osWait(100);
        semPost(TEST_SEM_ID8, NULL);
    }
}



static void Task87(void) {
    while(1) {
        semGain(TEST_SEM_ID8, test_sem8);
        group8_count--;
        osWait(100);
        semPost(TEST_SEM_ID8, NULL);
    }
}



static void Task88(void) {
    while(1) {
        semGain(TEST_SEM_ID8, test_sem8);
        group8_count--;
        osWait(100);
        semPost(TEST_SEM_ID8, NULL);
    }
}



static void Task89(void) {
    while(1) {
        semGain(TEST_SEM_ID8, test_sem8);
        group8_count--;
        osWait(100);
        semPost(TEST_SEM_ID8, NULL);
    }
}



static void Task90(void) {
    while(1) {
        semGain(TEST_SEM_ID9, test_sem9);
        group9_count--;
        osWait(100);
        semPost(TEST_SEM_ID9, NULL);
    }
}



static void Task91(void) {
    while(1) {
        semGain(TEST_SEM_ID9, test_sem9);
        group9_count--;
        osWait(100);
        semPost(TEST_SEM_ID9, NULL);
    }
}



static void Task92(void) {
    while(1) {
        semGain(TEST_SEM_ID9, test_sem9);
        group9_count--;
        osWait(100);
        semPost(TEST_SEM_ID9, NULL);
    }
}



static void Task93(void) {
    while(1) {
        semGain(TEST_SEM_ID9, test_sem9);
        group9_count--;
        osWait(100);
        semPost(TEST_SEM_ID9, NULL);
    }
}



static void Task94(void) {
    while(1) {
        semGain(TEST_SEM_ID9, test_sem9);
        group9_count--;
        osWait(11);
        semPost(TEST_SEM_ID9, NULL);
    }
}



static void Task95(void) {
    while(1) {
        semGain(TEST_SEM_ID9, NULL);
        group9_count++;
        osWait(100);
        semPost(TEST_SEM_ID9, test_sem9);
    }
}



static void Task96(void) {
    while(1) {
        semGain(TEST_SEM_ID9, NULL);
        group9_count++;
        osWait(20);
        semPost(TEST_SEM_ID9, test_sem9);
    }
}



static void Task97(void) {
    while(1) {
        semGain(TEST_SEM_ID9, NULL);
        group9_count++;
        osWait(50);
        semPost(TEST_SEM_ID9, test_sem9);
    }
}



static void Task98(void) {
    while(1) {
        semGain(TEST_SEM_ID9, NULL);
        group9_count++;
        osWait(10);
        semPost(TEST_SEM_ID9, test_sem9);
    }
}



static void Task99(void) {
    while(1) {
        semGain(TEST_SEM_ID9, NULL);
        group9_count++;
        osWait(10);
        semPost(TEST_SEM_ID9, test_sem9);
    }
}




void Main(void) {
    test_sem0  = semInit(TEST_SEM_ID0, 1);
    test_sem1  = semInit(TEST_SEM_ID1, 1);
    test_sem2  = semInit(TEST_SEM_ID2, 1);
    test_sem3  = semInit(TEST_SEM_ID3, 1);
    test_sem4  = semInit(TEST_SEM_ID4, 1);
    test_sem5  = semInit(TEST_SEM_ID5, 1);
    test_sem6  = semInit(TEST_SEM_ID6, 1);
    test_sem7  = semInit(TEST_SEM_ID7, 1);
    test_sem8  = semInit(TEST_SEM_ID8, 1);
    test_sem9  = semInit(TEST_SEM_ID9, 1);


    osInitTask(Task0, 100, 0, 5, STACK_SIZE);
    osInitTask(Task1, 101, 1, 5, STACK_SIZE);
    osInitTask(Task2, 102, 2, 5, STACK_SIZE);
    osInitTask(Task3, 103, 3, 5, STACK_SIZE);
    osInitTask(Task4, 104, 4, 5, STACK_SIZE);
    osInitTask(Task5, 105, 5, 5, STACK_SIZE);
    osInitTask(Task6, 106, 6, 5, STACK_SIZE);
    osInitTask(Task7, 107, 7, 5, STACK_SIZE);
    osInitTask(Task8, 108, 8, 5, STACK_SIZE);
    osInitTask(Task9, 109, 9, 5, STACK_SIZE);
    osInitTask(Task10, 110, 10, 5, STACK_SIZE);
    osInitTask(Task11, 111, 11, 5, STACK_SIZE);
    osInitTask(Task12, 112, 12, 5, STACK_SIZE);
    osInitTask(Task13, 113, 13, 5, STACK_SIZE);
    osInitTask(Task14, 114, 14, 5, STACK_SIZE);
    osInitTask(Task15, 115, 15, 5, STACK_SIZE);
    osInitTask(Task16, 116, 16, 5, STACK_SIZE);
    osInitTask(Task17, 117, 17, 5, STACK_SIZE);
    osInitTask(Task18, 118, 18, 5, STACK_SIZE);
    osInitTask(Task19, 119, 19, 5, STACK_SIZE);
    osInitTask(Task20, 120, 20, 5, STACK_SIZE);
    osInitTask(Task21, 121, 21, 5, STACK_SIZE);
    osInitTask(Task22, 122, 22, 5, STACK_SIZE);
    osInitTask(Task23, 123, 23, 5, STACK_SIZE);
    osInitTask(Task24, 124, 24, 5, STACK_SIZE);
    osInitTask(Task25, 125, 25, 5, STACK_SIZE);
    osInitTask(Task26, 126, 26, 5, STACK_SIZE);
    osInitTask(Task27, 127, 27, 5, STACK_SIZE);
    osInitTask(Task28, 128, 28, 5, STACK_SIZE);
    osInitTask(Task29, 129, 29, 5, STACK_SIZE);
    osInitTask(Task30, 130, 30, 5, STACK_SIZE);
    osInitTask(Task31, 131, 31, 5, STACK_SIZE);
    osInitTask(Task32, 132, 32, 5, STACK_SIZE);
    osInitTask(Task33, 133, 33, 5, STACK_SIZE);
    osInitTask(Task34, 134, 34, 5, STACK_SIZE);
    osInitTask(Task35, 135, 35, 5, STACK_SIZE);
    osInitTask(Task36, 136, 36, 5, STACK_SIZE);
    osInitTask(Task37, 137, 37, 5, STACK_SIZE);
    osInitTask(Task38, 138, 38, 5, STACK_SIZE);
    osInitTask(Task39, 139, 39, 5, STACK_SIZE);
    osInitTask(Task40, 140, 40, 5, STACK_SIZE);
    osInitTask(Task41, 141, 41, 5, STACK_SIZE);
    osInitTask(Task42, 142, 42, 5, STACK_SIZE);
    osInitTask(Task43, 143, 43, 5, STACK_SIZE);
    osInitTask(Task44, 144, 44, 5, STACK_SIZE);
    osInitTask(Task45, 145, 45, 5, STACK_SIZE);
    osInitTask(Task46, 146, 46, 5, STACK_SIZE);
    osInitTask(Task47, 147, 47, 5, STACK_SIZE);
    osInitTask(Task48, 148, 48, 5, STACK_SIZE);
    osInitTask(Task49, 149, 49, 5, STACK_SIZE);
    osInitTask(Task50, 150, 50, 5, STACK_SIZE);
    osInitTask(Task51, 151, 51, 5, STACK_SIZE);
    osInitTask(Task52, 152, 52, 5, STACK_SIZE);
    osInitTask(Task53, 153, 53, 5, STACK_SIZE);
    osInitTask(Task54, 154, 54, 5, STACK_SIZE);
    osInitTask(Task55, 155, 55, 5, STACK_SIZE);
    osInitTask(Task56, 156, 56, 5, STACK_SIZE);
    osInitTask(Task57, 157, 57, 5, STACK_SIZE);
    osInitTask(Task58, 158, 58, 5, STACK_SIZE);
    osInitTask(Task59, 159, 59, 5, STACK_SIZE);
    osInitTask(Task60, 160, 60, 5, STACK_SIZE);
    osInitTask(Task61, 161, 61, 5, STACK_SIZE);
    osInitTask(Task62, 162, 62, 5, STACK_SIZE);
    osInitTask(Task63, 163, 63, 5, STACK_SIZE);
    osInitTask(Task64, 164, 0, 5, STACK_SIZE);
    osInitTask(Task65, 165, 1, 5, STACK_SIZE);
    osInitTask(Task66, 166, 2, 5, STACK_SIZE);
    osInitTask(Task67, 167, 3, 5, STACK_SIZE);
    osInitTask(Task68, 168, 4, 5, STACK_SIZE);
    osInitTask(Task69, 169, 5, 5, STACK_SIZE);
    osInitTask(Task70, 170, 6, 5, STACK_SIZE);
    osInitTask(Task71, 171, 7, 5, STACK_SIZE);
    osInitTask(Task72, 172, 8, 5, STACK_SIZE);
    osInitTask(Task73, 173, 9, 5, STACK_SIZE);
    osInitTask(Task74, 174, 10, 5, STACK_SIZE);
    osInitTask(Task75, 175, 11, 5, STACK_SIZE);
    osInitTask(Task76, 176, 12, 5, STACK_SIZE);
    osInitTask(Task77, 177, 13, 5, STACK_SIZE);
    osInitTask(Task78, 178, 14, 5, STACK_SIZE);
    osInitTask(Task79, 179, 15, 5, STACK_SIZE);
    osInitTask(Task80, 180, 16, 5, STACK_SIZE);
    osInitTask(Task81, 181, 17, 5, STACK_SIZE);
    osInitTask(Task82, 182, 18, 5, STACK_SIZE);
    osInitTask(Task83, 183, 19, 5, STACK_SIZE);
    osInitTask(Task84, 184, 20, 5, STACK_SIZE);
    osInitTask(Task85, 185, 21, 5, STACK_SIZE);
    osInitTask(Task86, 186, 22, 5, STACK_SIZE);
    osInitTask(Task87, 187, 23, 5, STACK_SIZE);
    osInitTask(Task88, 188, 24, 5, STACK_SIZE);
    osInitTask(Task89, 189, 25, 5, STACK_SIZE);
    osInitTask(Task90, 190, 26, 5, STACK_SIZE);
    osInitTask(Task91, 191, 27, 5, STACK_SIZE);
    osInitTask(Task92, 192, 28, 5, STACK_SIZE);
    osInitTask(Task93, 193, 29, 5, STACK_SIZE);
    osInitTask(Task94, 194, 30, 5, STACK_SIZE);
    osInitTask(Task95, 195, 31, 5, STACK_SIZE);
    osInitTask(Task96, 196, 32, 5, STACK_SIZE);
    osInitTask(Task97, 197, 33, 5, STACK_SIZE);
    osInitTask(Task98, 198, 34, 5, STACK_SIZE);
    osInitTask(Task99, 199, 35, 5, STACK_SIZE);
}
